{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:50:56.537763Z",
     "start_time": "2025-01-26T08:50:53.122538Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:50:57.812052Z",
     "start_time": "2025-01-26T08:50:56.538334Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:51:03.181016Z",
     "start_time": "2025-01-26T08:50:57.813052Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])\n",
    ")\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:51:03.193002Z",
     "start_time": "2025-01-26T08:51:03.182002Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),  # in_features=784, out_features=300\n",
    "            nn.SELU(),\n",
    "        )\n",
    "        # 加19层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"selu\", nn.SELU()) # 这里采用SELU激活函数\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 10000\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 10000\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 10000\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 10000\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 10000\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 10000\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 10000\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 10000\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 10000\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 10000\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_20\tparamerters num: 1000\n",
      "Linear_20\tparamerters num: 10\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:51:04.093199Z",
     "start_time": "2025-01-26T08:51:04.048237Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:51:08.139028Z",
     "start_time": "2025-01-26T08:51:04.819335Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:51:08.144678Z",
     "start_time": "2025-01-26T08:51:08.140028Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:51:08.151348Z",
     "start_time": "2025-01-26T08:51:08.144678Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:58:18.741776Z",
     "start_time": "2025-01-26T08:51:08.152462Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/selu\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints/selu\"):\n",
    "    #创建多级目录\n",
    "    os.makedirs(\"checkpoints/selu\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/selu\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "cd4518b6744748e6842365b0c77fd9f7"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 23 / global_step 86250\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T08:58:19.010749Z",
     "start_time": "2025-01-26T08:58:18.743044Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "markdown",
   "source": [
    "## selu激活函数，可以加速收敛，效果相对于relu更好"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T10:14:47.188905Z",
     "start_time": "2025-01-26T10:14:46.149430Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/selu/best.ckpt\", weights_only=True, map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3915\n",
      "accuracy: 0.8812\n"
     ]
    }
   ],
   "execution_count": 11
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
